home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume13 / rpc3.9 / part04 < prev    next >
Encoding:
Internet Message Format  |  1988-02-27  |  53.6 KB
  1. Subject:  v13i081:  Sun RPC, release 3.9, Part04/10
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: Stephen X. Nahm <sxn@Sun.COM>
  7. Posting-number: Volume 13, Issue 81
  8. Archive-name: rpc3.9/part04
  9.  
  10. #! /bin/sh
  11. # This is a shell archive. To extract, remove the header and type "sh filename"
  12. #
  13. cd rpc
  14. echo x - svc.h
  15. cat > svc.h <<'Funky_Stuff'
  16. /* @(#)svc.h    1.2 87/11/09 3.9 RPCSRC */
  17. /*
  18.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  19.  * unrestricted use provided that this legend is included on all tape
  20.  * media and as a part of the software program in whole or part.  Users
  21.  * may copy or modify Sun RPC without charge, but are not authorized
  22.  * to license or distribute it to anyone else except as part of a product or
  23.  * program developed by the user.
  24.  * 
  25.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  26.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  27.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  28.  * 
  29.  * Sun RPC is provided with no support and without any obligation on the
  30.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  31.  * modification or enhancement.
  32.  * 
  33.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  34.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  35.  * OR ANY PART THEREOF.
  36.  * 
  37.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  38.  * or profits or other special, indirect and consequential damages, even if
  39.  * Sun has been advised of the possibility of such damages.
  40.  * 
  41.  * Sun Microsystems, Inc.
  42.  * 2550 Garcia Avenue
  43.  * Mountain View, California  94043
  44.  */
  45. /*      @(#)svc.h 1.18 87/07/14 SMI      *
  46.  
  47. /*
  48.  * svc.h, Server-side remote procedure call interface.
  49.  *
  50.  * Copyright (C) 1984, Sun Microsystems, Inc.
  51.  */
  52.  
  53. #ifndef __SVC_HEADER__
  54. #define __SVC_HEADER__
  55.  
  56. /*
  57.  * This interface must manage two items concerning remote procedure calling:
  58.  *
  59.  * 1) An arbitrary number of transport connections upon which rpc requests
  60.  * are received.  The two most notable transports are TCP and UDP;  they are
  61.  * created and registered by routines in svc_tcp.c and svc_udp.c, respectively;
  62.  * they in turn call xprt_register and xprt_unregister.
  63.  *
  64.  * 2) An arbitrary number of locally registered services.  Services are
  65.  * described by the following four data: program number, version number,
  66.  * "service dispatch" function, a transport handle, and a boolean that
  67.  * indicates whether or not the exported program should be registered with a
  68.  * local binder service;  if true the program's number and version and the
  69.  * port number from the transport handle are registered with the binder.
  70.  * These data are registered with the rpc svc system via svc_register.
  71.  *
  72.  * A service's dispatch function is called whenever an rpc request comes in
  73.  * on a transport.  The request's program and version numbers must match
  74.  * those of the registered service.  The dispatch function is passed two
  75.  * parameters, struct svc_req * and SVCXPRT *, defined below.
  76.  */
  77.  
  78. enum xprt_stat {
  79.     XPRT_DIED,
  80.     XPRT_MOREREQS,
  81.     XPRT_IDLE
  82. };
  83.  
  84. /*
  85.  * Server side transport handle
  86.  */
  87. typedef struct {
  88.     int        xp_sock;
  89.     u_short        xp_port;     /* associated port number */
  90.     struct xp_ops {
  91.         bool_t    (*xp_recv)();     /* receive incomming requests */
  92.         enum xprt_stat (*xp_stat)(); /* get transport status */
  93.         bool_t    (*xp_getargs)(); /* get arguments */
  94.         bool_t    (*xp_reply)();     /* send reply */
  95.         bool_t    (*xp_freeargs)();/* free mem allocated for args */
  96.         void    (*xp_destroy)(); /* destroy this struct */
  97.     } *xp_ops;
  98.     int        xp_addrlen;     /* length of remote address */
  99.     struct sockaddr_in xp_raddr;     /* remote address */
  100.     struct opaque_auth xp_verf;     /* raw response verifier */
  101.     caddr_t        xp_p1;         /* private */
  102.     caddr_t        xp_p2;         /* private */
  103. } SVCXPRT;
  104.  
  105. /*
  106.  *  Approved way of getting address of caller
  107.  */
  108. #define svc_getcaller(x) (&(x)->xp_raddr)
  109.  
  110. /*
  111.  * Operations defined on an SVCXPRT handle
  112.  *
  113.  * SVCXPRT        *xprt;
  114.  * struct rpc_msg    *msg;
  115.  * xdrproc_t         xargs;
  116.  * caddr_t         argsp;
  117.  */
  118. #define SVC_RECV(xprt, msg)                \
  119.     (*(xprt)->xp_ops->xp_recv)((xprt), (msg))
  120. #define svc_recv(xprt, msg)                \
  121.     (*(xprt)->xp_ops->xp_recv)((xprt), (msg))
  122.  
  123. #define SVC_STAT(xprt)                    \
  124.     (*(xprt)->xp_ops->xp_stat)(xprt)
  125. #define svc_stat(xprt)                    \
  126.     (*(xprt)->xp_ops->xp_stat)(xprt)
  127.  
  128. #define SVC_GETARGS(xprt, xargs, argsp)            \
  129.     (*(xprt)->xp_ops->xp_getargs)((xprt), (xargs), (argsp))
  130. #define svc_getargs(xprt, xargs, argsp)            \
  131.     (*(xprt)->xp_ops->xp_getargs)((xprt), (xargs), (argsp))
  132.  
  133. #define SVC_REPLY(xprt, msg)                \
  134.     (*(xprt)->xp_ops->xp_reply) ((xprt), (msg))
  135. #define svc_reply(xprt, msg)                \
  136.     (*(xprt)->xp_ops->xp_reply) ((xprt), (msg))
  137.  
  138. #define SVC_FREEARGS(xprt, xargs, argsp)        \
  139.     (*(xprt)->xp_ops->xp_freeargs)((xprt), (xargs), (argsp))
  140. #define svc_freeargs(xprt, xargs, argsp)        \
  141.     (*(xprt)->xp_ops->xp_freeargs)((xprt), (xargs), (argsp))
  142.  
  143. #define SVC_DESTROY(xprt)                \
  144.     (*(xprt)->xp_ops->xp_destroy)(xprt)
  145. #define svc_destroy(xprt)                \
  146.     (*(xprt)->xp_ops->xp_destroy)(xprt)
  147.  
  148.  
  149. /*
  150.  * Service request
  151.  */
  152. struct svc_req {
  153.     u_long        rq_prog;    /* service program number */
  154.     u_long        rq_vers;    /* service protocol version */
  155.     u_long        rq_proc;    /* the desired procedure */
  156.     struct opaque_auth rq_cred;    /* raw creds from the wire */
  157.     caddr_t        rq_clntcred;    /* read only cooked cred */
  158.     SVCXPRT    *rq_xprt;        /* associated transport */
  159. };
  160.  
  161.  
  162. /*
  163.  * Service registration
  164.  *
  165.  * svc_register(xprt, prog, vers, dispatch, protocol)
  166.  *    SVCXPRT *xprt;
  167.  *    u_long prog;
  168.  *    u_long vers;
  169.  *    void (*dispatch)();
  170.  *    int protocol;  /* like TCP or UDP, zero means do not register 
  171.  */
  172. extern bool_t    svc_register();
  173.  
  174. /*
  175.  * Service un-registration
  176.  *
  177.  * svc_unregister(prog, vers)
  178.  *    u_long prog;
  179.  *    u_long vers;
  180.  */
  181. extern void    svc_unregister();
  182.  
  183. /*
  184.  * Transport registration.
  185.  *
  186.  * xprt_register(xprt)
  187.  *    SVCXPRT *xprt;
  188.  */
  189. extern void    xprt_register();
  190.  
  191. /*
  192.  * Transport un-register
  193.  *
  194.  * xprt_unregister(xprt)
  195.  *    SVCXPRT *xprt;
  196.  */
  197. extern void    xprt_unregister();
  198.  
  199.  
  200.  
  201.  
  202. /*
  203.  * When the service routine is called, it must first check to see if it
  204.  * knows about the procedure;  if not, it should call svcerr_noproc
  205.  * and return.  If so, it should deserialize its arguments via 
  206.  * SVC_GETARGS (defined above).  If the deserialization does not work,
  207.  * svcerr_decode should be called followed by a return.  Successful
  208.  * decoding of the arguments should be followed the execution of the
  209.  * procedure's code and a call to svc_sendreply.
  210.  *
  211.  * Also, if the service refuses to execute the procedure due to too-
  212.  * weak authentication parameters, svcerr_weakauth should be called.
  213.  * Note: do not confuse access-control failure with weak authentication!
  214.  *
  215.  * NB: In pure implementations of rpc, the caller always waits for a reply
  216.  * msg.  This message is sent when svc_sendreply is called.  
  217.  * Therefore pure service implementations should always call
  218.  * svc_sendreply even if the function logically returns void;  use
  219.  * xdr.h - xdr_void for the xdr routine.  HOWEVER, tcp based rpc allows
  220.  * for the abuse of pure rpc via batched calling or pipelining.  In the
  221.  * case of a batched call, svc_sendreply should NOT be called since
  222.  * this would send a return message, which is what batching tries to avoid.
  223.  * It is the service/protocol writer's responsibility to know which calls are
  224.  * batched and which are not.  Warning: responding to batch calls may
  225.  * deadlock the caller and server processes!
  226.  */
  227.  
  228. extern bool_t  svc_sendreply();
  229. extern void    svcerr_decode();
  230. extern void    svcerr_weakauth();
  231. extern void    svcerr_noproc();
  232.  
  233. /*
  234.  * Lowest level dispatching -OR- who owns this process anyway.
  235.  * Somebody has to wait for incoming requests and then call the correct
  236.  * service routine.  The routine svc_run does infinite waiting; i.e.,
  237.  * svc_run never returns.
  238.  * Since another (co-existant) package may wish to selectively wait for
  239.  * incoming calls or other events outside of the rpc architecture, the
  240.  * routine svc_getreq is provided.  It must be passed readfds, the
  241.  * "in-place" results of a select system call (see select, section 2).
  242.  */
  243.  
  244. /*
  245.  * Global keeper of rpc service descriptors in use
  246.  * dynamic; must be inspected before each call to select 
  247.  */
  248. #ifdef FD_SETSIZE
  249. extern fd_set svc_fdset;
  250. #define svc_fds svc_fdset.fds_bits[0]    /* compatibility */
  251. #else
  252. extern int svc_fds;
  253. #endif /* def FD_SETSIZE */
  254.  
  255. /*
  256.  * a small program implemented by the svc_rpc implementation itself;
  257.  * also see clnt.h for protocol numbers.
  258.  */
  259. extern void rpctest_service();
  260.  
  261. extern void    svc_getreq();
  262. extern void    svc_getreqset();    /* takes fdset instead of int */
  263. extern void    svc_run();      /* never returns */
  264.  
  265. /*
  266.  * Socket to use on svcxxx_create call to get default socket
  267.  */
  268. #define    RPC_ANYSOCK    -1
  269.  
  270. /*
  271.  * These are the existing service side transport implementations
  272.  */
  273.  
  274. /*
  275.  * Memory based rpc for testing and timing.
  276.  */
  277. extern SVCXPRT *svcraw_create();
  278.  
  279. /*
  280.  * Udp based rpc.
  281.  */
  282. extern SVCXPRT *svcudp_create();
  283. extern SVCXPRT *svcudp_bufcreate();
  284.  
  285. /*
  286.  * Tcp based rpc.
  287.  */
  288. extern SVCXPRT *svctcp_create();
  289.  
  290.  
  291.  
  292. #endif !__SVC_HEADER__
  293. Funky_Stuff
  294. len=`wc -c < svc.h`
  295. if [ $len !=     8701 ] ; then
  296.   echo error: svc.h was $len bytes long, should have been     8701
  297. fi
  298. echo x - svc_auth.c
  299. cat > svc_auth.c <<'Funky_Stuff'
  300. /* @(#)svc_auth.c    1.1 87/11/04 3.9 RPCSRC */
  301. /*
  302.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  303.  * unrestricted use provided that this legend is included on all tape
  304.  * media and as a part of the software program in whole or part.  Users
  305.  * may copy or modify Sun RPC without charge, but are not authorized
  306.  * to license or distribute it to anyone else except as part of a product or
  307.  * program developed by the user.
  308.  * 
  309.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  310.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  311.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  312.  * 
  313.  * Sun RPC is provided with no support and without any obligation on the
  314.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  315.  * modification or enhancement.
  316.  * 
  317.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  318.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  319.  * OR ANY PART THEREOF.
  320.  * 
  321.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  322.  * or profits or other special, indirect and consequential damages, even if
  323.  * Sun has been advised of the possibility of such damages.
  324.  * 
  325.  * Sun Microsystems, Inc.
  326.  * 2550 Garcia Avenue
  327.  * Mountain View, California  94043
  328.  */
  329. #if !defined(lint) && defined(SCCSIDS)
  330. static char sccsid[] = "@(#)svc_auth.c 1.19 87/08/11 Copyr 1984 Sun Micro";
  331. #endif
  332.  
  333. /*
  334.  * svc_auth.c, Server-side rpc authenticator interface.
  335.  *
  336.  * Copyright (C) 1984, Sun Microsystems, Inc.
  337.  */
  338.  
  339. #include <rpc/rpc.h>
  340.  
  341. /*
  342.  * svcauthsw is the bdevsw of server side authentication. 
  343.  * 
  344.  * Server side authenticators are called from authenticate by
  345.  * using the client auth struct flavor field to index into svcauthsw.
  346.  * The server auth flavors must implement a routine that looks  
  347.  * like: 
  348.  * 
  349.  *    enum auth_stat
  350.  *    flavorx_auth(rqst, msg)
  351.  *        register struct svc_req *rqst; 
  352.  *        register struct rpc_msg *msg;
  353.  *
  354.  */
  355.  
  356. enum auth_stat _svcauth_null();        /* no authentication */
  357. enum auth_stat _svcauth_unix();        /* unix style (uid, gids) */
  358. enum auth_stat _svcauth_short();    /* short hand unix style */
  359.  
  360. static struct {
  361.     enum auth_stat (*authenticator)();
  362. } svcauthsw[] = {
  363.     _svcauth_null,            /* AUTH_NULL */
  364.     _svcauth_unix,            /* AUTH_UNIX */
  365.     _svcauth_short,            /* AUTH_SHORT */
  366. };
  367. #define    AUTH_MAX    2        /* HIGHEST AUTH NUMBER */
  368.  
  369.  
  370. /*
  371.  * The call rpc message, msg has been obtained from the wire.  The msg contains
  372.  * the raw form of credentials and verifiers.  authenticate returns AUTH_OK
  373.  * if the msg is successfully authenticated.  If AUTH_OK then the routine also
  374.  * does the following things:
  375.  * set rqst->rq_xprt->verf to the appropriate response verifier;
  376.  * sets rqst->rq_client_cred to the "cooked" form of the credentials.
  377.  *
  378.  * NB: rqst->rq_cxprt->verf must be pre-alloctaed;
  379.  * its length is set appropriately.
  380.  *
  381.  * The caller still owns and is responsible for msg->u.cmb.cred and
  382.  * msg->u.cmb.verf.  The authentication system retains ownership of
  383.  * rqst->rq_client_cred, the cooked credentials.
  384.  *
  385.  * There is an assumption that any flavour less than AUTH_NULL is
  386.  * invalid.
  387.  */
  388. enum auth_stat
  389. _authenticate(rqst, msg)
  390.     register struct svc_req *rqst;
  391.     struct rpc_msg *msg;
  392. {
  393.     register int cred_flavor;
  394.  
  395.     rqst->rq_cred = msg->rm_call.cb_cred;
  396.     rqst->rq_xprt->xp_verf.oa_flavor = _null_auth.oa_flavor;
  397.     rqst->rq_xprt->xp_verf.oa_length = 0;
  398.     cred_flavor = rqst->rq_cred.oa_flavor;
  399.     if ((cred_flavor <= AUTH_MAX) && (cred_flavor >= AUTH_NULL)) {
  400.         return ((*(svcauthsw[cred_flavor].authenticator))(rqst, msg));
  401.     }
  402.  
  403.     return (AUTH_REJECTEDCRED);
  404. }
  405.  
  406. enum auth_stat
  407. _svcauth_null(/*rqst, msg*/)
  408.     /*struct svc_req *rqst;
  409.     struct rpc_msg *msg;*/
  410. {
  411.  
  412.     return (AUTH_OK);
  413. }
  414. Funky_Stuff
  415. len=`wc -c < svc_auth.c`
  416. if [ $len !=     3726 ] ; then
  417.   echo error: svc_auth.c was $len bytes long, should have been     3726
  418. fi
  419. echo x - svc_auth.h
  420. cat > svc_auth.h <<'Funky_Stuff'
  421. /* @(#)svc_auth.h    1.1 87/11/04 3.9 RPCSRC */
  422. /*
  423.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  424.  * unrestricted use provided that this legend is included on all tape
  425.  * media and as a part of the software program in whole or part.  Users
  426.  * may copy or modify Sun RPC without charge, but are not authorized
  427.  * to license or distribute it to anyone else except as part of a product or
  428.  * program developed by the user.
  429.  * 
  430.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  431.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  432.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  433.  * 
  434.  * Sun RPC is provided with no support and without any obligation on the
  435.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  436.  * modification or enhancement.
  437.  * 
  438.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  439.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  440.  * OR ANY PART THEREOF.
  441.  * 
  442.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  443.  * or profits or other special, indirect and consequential damages, even if
  444.  * Sun has been advised of the possibility of such damages.
  445.  * 
  446.  * Sun Microsystems, Inc.
  447.  * 2550 Garcia Avenue
  448.  * Mountain View, California  94043
  449.  */
  450. /*      @(#)svc_auth.h 1.6 86/07/16 SMI      */
  451.  
  452. /*
  453.  * svc_auth.h, Service side of rpc authentication.
  454.  * 
  455.  * Copyright (C) 1984, Sun Microsystems, Inc.
  456.  */
  457.  
  458.  
  459. /*
  460.  * Server side authenticator
  461.  */
  462. extern enum auth_stat _authenticate();
  463. Funky_Stuff
  464. len=`wc -c < svc_auth.h`
  465. if [ $len !=     1548 ] ; then
  466.   echo error: svc_auth.h was $len bytes long, should have been     1548
  467. fi
  468. echo x - svc_auth_unix.c
  469. cat > svc_auth_unix.c <<'Funky_Stuff'
  470. /* @(#)svc_auth_unix.c    1.1 87/11/04 3.9 RPCSRC */
  471. /*
  472.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  473.  * unrestricted use provided that this legend is included on all tape
  474.  * media and as a part of the software program in whole or part.  Users
  475.  * may copy or modify Sun RPC without charge, but are not authorized
  476.  * to license or distribute it to anyone else except as part of a product or
  477.  * program developed by the user.
  478.  * 
  479.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  480.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  481.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  482.  * 
  483.  * Sun RPC is provided with no support and without any obligation on the
  484.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  485.  * modification or enhancement.
  486.  * 
  487.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  488.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  489.  * OR ANY PART THEREOF.
  490.  * 
  491.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  492.  * or profits or other special, indirect and consequential damages, even if
  493.  * Sun has been advised of the possibility of such damages.
  494.  * 
  495.  * Sun Microsystems, Inc.
  496.  * 2550 Garcia Avenue
  497.  * Mountain View, California  94043
  498.  */
  499. #if !defined(lint) && defined(SCCSIDS)
  500. static char sccsid[] = "@(#)svc_auth_unix.c 1.26 87/08/11 Copyr 1984 Sun Micro";
  501. #endif
  502.  
  503. /*
  504.  * svc_auth_unix.c
  505.  * Handles UNIX flavor authentication parameters on the service side of rpc.
  506.  * There are two svc auth implementations here: AUTH_UNIX and AUTH_SHORT.
  507.  * _svcauth_unix does full blown unix style uid,gid+gids auth,
  508.  * _svcauth_short uses a shorthand auth to index into a cache of longhand auths.
  509.  * Note: the shorthand has been gutted for efficiency.
  510.  *
  511.  * Copyright (C) 1984, Sun Microsystems, Inc.
  512.  */
  513.  
  514. #include <stdio.h>
  515. #include <sys/time.h>
  516. #include <rpc/rpc.h>
  517.  
  518. /*
  519.  * Unix longhand authenticator
  520.  */
  521. enum auth_stat
  522. _svcauth_unix(rqst, msg)
  523.     register struct svc_req *rqst;
  524.     register struct rpc_msg *msg;
  525. {
  526.     register enum auth_stat stat;
  527.     XDR xdrs;
  528.     register struct authunix_parms *aup;
  529.     register long *buf;
  530.     struct area {
  531.         struct authunix_parms area_aup;
  532.         char area_machname[MAX_MACHINE_NAME];
  533.         int area_gids[NGRPS];
  534.     } *area;
  535.     u_int auth_len;
  536.     int str_len, gid_len;
  537.     register int i;
  538.  
  539.     area = (struct area *) rqst->rq_clntcred;
  540.     aup = &area->area_aup;
  541.     aup->aup_machname = area->area_machname;
  542.     aup->aup_gids = area->area_gids;
  543.     auth_len = (u_int)msg->rm_call.cb_cred.oa_length;
  544.     xdrmem_create(&xdrs, msg->rm_call.cb_cred.oa_base, auth_len,XDR_DECODE);
  545.     buf = XDR_INLINE(&xdrs, auth_len);
  546.     if (buf != NULL) {
  547.         aup->aup_time = IXDR_GET_LONG(buf);
  548.         str_len = IXDR_GET_U_LONG(buf);
  549.         bcopy((caddr_t)buf, aup->aup_machname, (u_int)str_len);
  550.         aup->aup_machname[str_len] = 0;
  551.         str_len = RNDUP(str_len);
  552.         buf += str_len / sizeof (long);
  553.         aup->aup_uid = IXDR_GET_LONG(buf);
  554.         aup->aup_gid = IXDR_GET_LONG(buf);
  555.         gid_len = IXDR_GET_U_LONG(buf);
  556.         if (gid_len > NGRPS) {
  557.             stat = AUTH_BADCRED;
  558.             goto done;
  559.         }
  560.         aup->aup_len = gid_len;
  561.         for (i = 0; i < gid_len; i++) {
  562.             aup->aup_gids[i] = IXDR_GET_LONG(buf);
  563.         }
  564.         /*
  565.          * five is the smallest unix credentials structure -
  566.          * timestamp, hostname len (0), uid, gid, and gids len (0).
  567.          */
  568.         if ((5 + gid_len) * BYTES_PER_XDR_UNIT + str_len > auth_len) {
  569.             (void) printf("bad auth_len gid %d str %d auth %d\n",
  570.                 gid_len, str_len, auth_len);
  571.             stat = AUTH_BADCRED;
  572.             goto done;
  573.         }
  574.     } else if (! xdr_authunix_parms(&xdrs, aup)) {
  575.         xdrs.x_op = XDR_FREE;
  576.         (void)xdr_authunix_parms(&xdrs, aup);
  577.         stat = AUTH_BADCRED;
  578.         goto done;
  579.     }
  580.     rqst->rq_xprt->xp_verf.oa_flavor = AUTH_NULL;
  581.     rqst->rq_xprt->xp_verf.oa_length = 0;
  582.     stat = AUTH_OK;
  583. done:
  584.     XDR_DESTROY(&xdrs);
  585.     return (stat);
  586. }
  587.  
  588.  
  589. /*
  590.  * Shorthand unix authenticator
  591.  * Looks up longhand in a cache.
  592.  */
  593. /*ARGSUSED*/
  594. enum auth_stat 
  595. _svcauth_short(rqst, msg)
  596.     struct svc_req *rqst;
  597.     struct rpc_msg *msg;
  598. {
  599.     return (AUTH_REJECTEDCRED);
  600. }
  601. Funky_Stuff
  602. len=`wc -c < svc_auth_unix.c`
  603. if [ $len !=     4026 ] ; then
  604.   echo error: svc_auth_unix.c was $len bytes long, should have been     4026
  605. fi
  606. echo x - svc_raw.c
  607. cat > svc_raw.c <<'Funky_Stuff'
  608. /* @(#)svc_raw.c    1.1 87/11/04 3.9 RPCSRC */
  609. /*
  610.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  611.  * unrestricted use provided that this legend is included on all tape
  612.  * media and as a part of the software program in whole or part.  Users
  613.  * may copy or modify Sun RPC without charge, but are not authorized
  614.  * to license or distribute it to anyone else except as part of a product or
  615.  * program developed by the user.
  616.  * 
  617.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  618.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  619.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  620.  * 
  621.  * Sun RPC is provided with no support and without any obligation on the
  622.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  623.  * modification or enhancement.
  624.  * 
  625.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  626.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  627.  * OR ANY PART THEREOF.
  628.  * 
  629.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  630.  * or profits or other special, indirect and consequential damages, even if
  631.  * Sun has been advised of the possibility of such damages.
  632.  * 
  633.  * Sun Microsystems, Inc.
  634.  * 2550 Garcia Avenue
  635.  * Mountain View, California  94043
  636.  */
  637. #if !defined(lint) && defined(SCCSIDS)
  638. static char sccsid[] = "@(#)svc_raw.c 1.15 87/08/11 Copyr 1984 Sun Micro";
  639. #endif
  640.  
  641. /*
  642.  * svc_raw.c,   This a toy for simple testing and timing.
  643.  * Interface to create an rpc client and server in the same UNIX process.
  644.  * This lets us similate rpc and get rpc (round trip) overhead, without
  645.  * any interference from the kernal.
  646.  *
  647.  * Copyright (C) 1984, Sun Microsystems, Inc.
  648.  */
  649.  
  650. #include <rpc/rpc.h>
  651.  
  652.  
  653. /*
  654.  * This is the "network" that we will be moving data over
  655.  */
  656. static struct svcraw_private {
  657.     char    _raw_buf[UDPMSGSIZE];
  658.     SVCXPRT    server;
  659.     XDR    xdr_stream;
  660.     char    verf_body[MAX_AUTH_BYTES];
  661. } *svcraw_private;
  662.  
  663. static bool_t        svcraw_recv();
  664. static enum xprt_stat     svcraw_stat();
  665. static bool_t        svcraw_getargs();
  666. static bool_t        svcraw_reply();
  667. static bool_t        svcraw_freeargs();
  668. static void        svcraw_destroy();
  669.  
  670. static struct xp_ops server_ops = {
  671.     svcraw_recv,
  672.     svcraw_stat,
  673.     svcraw_getargs,
  674.     svcraw_reply,
  675.     svcraw_freeargs,
  676.     svcraw_destroy
  677. };
  678.  
  679. SVCXPRT *
  680. svcraw_create()
  681. {
  682.     register struct svcraw_private *srp = svcraw_private;
  683.  
  684.     if (srp == 0) {
  685.         srp = (struct svcraw_private *)calloc(1, sizeof (*srp));
  686.         if (srp == 0)
  687.             return (0);
  688.     }
  689.     srp->server.xp_sock = 0;
  690.     srp->server.xp_port = 0;
  691.     srp->server.xp_ops = &server_ops;
  692.     srp->server.xp_verf.oa_base = srp->verf_body;
  693.     xdrmem_create(&srp->xdr_stream, srp->_raw_buf, UDPMSGSIZE, XDR_FREE);
  694.     return (&srp->server);
  695. }
  696.  
  697. static enum xprt_stat
  698. svcraw_stat()
  699. {
  700.  
  701.     return (XPRT_IDLE);
  702. }
  703.  
  704. static bool_t
  705. svcraw_recv(xprt, msg)
  706.     SVCXPRT *xprt;
  707.     struct rpc_msg *msg;
  708. {
  709.     register struct svcraw_private *srp = svcraw_private;
  710.     register XDR *xdrs;
  711.  
  712.     if (srp == 0)
  713.         return (0);
  714.     xdrs = &srp->xdr_stream;
  715.     xdrs->x_op = XDR_DECODE;
  716.     XDR_SETPOS(xdrs, 0);
  717.     if (! xdr_callmsg(xdrs, msg))
  718.            return (FALSE);
  719.     return (TRUE);
  720. }
  721.  
  722. static bool_t
  723. svcraw_reply(xprt, msg)
  724.     SVCXPRT *xprt;
  725.     struct rpc_msg *msg;
  726. {
  727.     register struct svcraw_private *srp = svcraw_private;
  728.     register XDR *xdrs;
  729.  
  730.     if (srp == 0)
  731.         return (FALSE);
  732.     xdrs = &srp->xdr_stream;
  733.     xdrs->x_op = XDR_ENCODE;
  734.     XDR_SETPOS(xdrs, 0);
  735.     if (! xdr_replymsg(xdrs, msg))
  736.            return (FALSE);
  737.     (void)XDR_GETPOS(xdrs);  /* called just for overhead */
  738.     return (TRUE);
  739. }
  740.  
  741. static bool_t
  742. svcraw_getargs(xprt, xdr_args, args_ptr)
  743.     SVCXPRT *xprt;
  744.     xdrproc_t xdr_args;
  745.     caddr_t args_ptr;
  746. {
  747.     register struct svcraw_private *srp = svcraw_private;
  748.  
  749.     if (srp == 0)
  750.         return (FALSE);
  751.     return ((*xdr_args)(&srp->xdr_stream, args_ptr));
  752. }
  753.  
  754. static bool_t
  755. svcraw_freeargs(xprt, xdr_args, args_ptr)
  756.     SVCXPRT *xprt;
  757.     xdrproc_t xdr_args;
  758.     caddr_t args_ptr;
  759. { 
  760.     register struct svcraw_private *srp = svcraw_private;
  761.     register XDR *xdrs;
  762.  
  763.     if (srp == 0)
  764.         return (FALSE);
  765.     xdrs = &srp->xdr_stream;
  766.     xdrs->x_op = XDR_FREE;
  767.     return ((*xdr_args)(xdrs, args_ptr));
  768. } 
  769.  
  770. static void
  771. svcraw_destroy()
  772. {
  773. }
  774. Funky_Stuff
  775. len=`wc -c < svc_raw.c`
  776. if [ $len !=     4120 ] ; then
  777.   echo error: svc_raw.c was $len bytes long, should have been     4120
  778. fi
  779. echo x - svc_run.c
  780. cat > svc_run.c <<'Funky_Stuff'
  781. /* @(#)svc_run.c    1.3 87/11/13 3.9 RPCSRC */
  782. #if !defined(lint) && defined(SCCSIDS)
  783. static char sccsid[] = "@(#)svc_run.c 1.1 87/10/13 Copyr 1984 Sun Micro";
  784. #endif
  785.  
  786. /*
  787.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  788.  * unrestricted use provided that this legend is included on all tape
  789.  * media and as a part of the software program in whole or part.  Users
  790.  * may copy or modify Sun RPC without charge, but are not authorized
  791.  * to license or distribute it to anyone else except as part of a product or
  792.  * program developed by the user.
  793.  * 
  794.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  795.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  796.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  797.  * 
  798.  * Sun RPC is provided with no support and without any obligation on the
  799.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  800.  * modification or enhancement.
  801.  * 
  802.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  803.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  804.  * OR ANY PART THEREOF.
  805.  * 
  806.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  807.  * or profits or other special, indirect and consequential damages, even if
  808.  * Sun has been advised of the possibility of such damages.
  809.  * 
  810.  * Sun Microsystems, Inc.
  811.  * 2550 Garcia Avenue
  812.  * Mountain View, California  94043
  813.  */
  814.  
  815. /*
  816.  * This is the rpc server side idle loop
  817.  * Wait for input, call server program.
  818.  */
  819. #include <rpc/rpc.h>
  820. #include <sys/errno.h>
  821.  
  822. void
  823. svc_run()
  824. {
  825. #ifdef FD_SETSIZE
  826.     fd_set readfds;
  827. #else
  828.       int readfds;
  829. #endif /* def FD_SETSIZE */
  830.     extern int errno;
  831.  
  832.     for (;;) {
  833. #ifdef FD_SETSIZE
  834.         readfds = svc_fdset;
  835. #else
  836.         readfds = svc_fds;
  837. #endif /* def FD_SETSIZE */
  838.         switch (select(_rpc_dtablesize(), &readfds, (int *)0, (int *)0,
  839.                    (struct timeval *)0)) {
  840.         case -1:
  841.             if (errno == EINTR) {
  842.                 continue;
  843.             }
  844.             perror("svc_run: - select failed");
  845.             return;
  846.         case 0:
  847.             continue;
  848.         default:
  849.             svc_getreqset(&readfds);
  850.         }
  851.     }
  852. }
  853. Funky_Stuff
  854. len=`wc -c < svc_run.c`
  855. if [ $len !=     2077 ] ; then
  856.   echo error: svc_run.c was $len bytes long, should have been     2077
  857. fi
  858. echo x - svc_simple.c
  859. cat > svc_simple.c <<'Funky_Stuff'
  860. /* @(#)svc_simple.c    1.1 87/11/04 3.9 RPCSRC */
  861. /*
  862.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  863.  * unrestricted use provided that this legend is included on all tape
  864.  * media and as a part of the software program in whole or part.  Users
  865.  * may copy or modify Sun RPC without charge, but are not authorized
  866.  * to license or distribute it to anyone else except as part of a product or
  867.  * program developed by the user.
  868.  * 
  869.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  870.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  871.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  872.  * 
  873.  * Sun RPC is provided with no support and without any obligation on the
  874.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  875.  * modification or enhancement.
  876.  * 
  877.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  878.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  879.  * OR ANY PART THEREOF.
  880.  * 
  881.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  882.  * or profits or other special, indirect and consequential damages, even if
  883.  * Sun has been advised of the possibility of such damages.
  884.  * 
  885.  * Sun Microsystems, Inc.
  886.  * 2550 Garcia Avenue
  887.  * Mountain View, California  94043
  888.  */
  889. #if !defined(lint) && defined(SCCSIDS)
  890. static char sccsid[] = "@(#)svc_simple.c 1.18 87/08/11 Copyr 1984 Sun Micro";
  891. #endif
  892.  
  893. /* 
  894.  * svc_simple.c
  895.  * Simplified front end to rpc.
  896.  *
  897.  * Copyright (C) 1984, Sun Microsystems, Inc.
  898.  */
  899.  
  900. #include <stdio.h>
  901. #include <rpc/rpc.h>
  902. #include <sys/socket.h>
  903. #include <sys/time.h>
  904. #include <netdb.h>
  905.  
  906. static struct proglst {
  907.     char *(*p_progname)();
  908.     int  p_prognum;
  909.     int  p_procnum;
  910.     xdrproc_t p_inproc, p_outproc;
  911.     struct proglst *p_nxt;
  912. } *proglst;
  913. static void universal();
  914. static SVCXPRT *transp;
  915. struct proglst *pl;
  916.  
  917. registerrpc(prognum, versnum, procnum, progname, inproc, outproc)
  918.     char *(*progname)();
  919.     xdrproc_t inproc, outproc;
  920. {
  921.     
  922.     if (procnum == NULLPROC) {
  923.         (void) fprintf(stderr,
  924.             "can't reassign procedure number %d\n", NULLPROC);
  925.         return (-1);
  926.     }
  927.     if (transp == 0) {
  928.         transp = svcudp_create(RPC_ANYSOCK);
  929.         if (transp == NULL) {
  930.             (void) fprintf(stderr, "couldn't create an rpc server\n");
  931.             return (-1);
  932.         }
  933.     }
  934.     (void) pmap_unset((u_long)prognum, (u_long)versnum);
  935.     if (!svc_register(transp, (u_long)prognum, (u_long)versnum, 
  936.         universal, IPPROTO_UDP)) {
  937.             (void) fprintf(stderr, "couldn't register prog %d vers %d\n",
  938.             prognum, versnum);
  939.         return (-1);
  940.     }
  941.     pl = (struct proglst *)malloc(sizeof(struct proglst));
  942.     if (pl == NULL) {
  943.         (void) fprintf(stderr, "registerrpc: out of memory\n");
  944.         return (-1);
  945.     }
  946.     pl->p_progname = progname;
  947.     pl->p_prognum = prognum;
  948.     pl->p_procnum = procnum;
  949.     pl->p_inproc = inproc;
  950.     pl->p_outproc = outproc;
  951.     pl->p_nxt = proglst;
  952.     proglst = pl;
  953.     return (0);
  954. }
  955.  
  956. static void
  957. universal(rqstp, transp)
  958.     struct svc_req *rqstp;
  959.     SVCXPRT *transp;
  960. {
  961.     int prog, proc;
  962.     char *outdata;
  963.     char xdrbuf[UDPMSGSIZE];
  964.     struct proglst *pl;
  965.  
  966.     /* 
  967.      * enforce "procnum 0 is echo" convention
  968.      */
  969.     if (rqstp->rq_proc == NULLPROC) {
  970.         if (svc_sendreply(transp, xdr_void, (char *)NULL) == FALSE) {
  971.             (void) fprintf(stderr, "xxx\n");
  972.             exit(1);
  973.         }
  974.         return;
  975.     }
  976.     prog = rqstp->rq_prog;
  977.     proc = rqstp->rq_proc;
  978.     for (pl = proglst; pl != NULL; pl = pl->p_nxt)
  979.         if (pl->p_prognum == prog && pl->p_procnum == proc) {
  980.             /* decode arguments into a CLEAN buffer */
  981.             bzero(xdrbuf, sizeof(xdrbuf)); /* required ! */
  982.             if (!svc_getargs(transp, pl->p_inproc, xdrbuf)) {
  983.                 svcerr_decode(transp);
  984.                 return;
  985.             }
  986.             outdata = (*(pl->p_progname))(xdrbuf);
  987.             if (outdata == NULL && pl->p_outproc != xdr_void)
  988.                 /* there was an error */
  989.                 return;
  990.             if (!svc_sendreply(transp, pl->p_outproc, outdata)) {
  991.                 (void) fprintf(stderr,
  992.                     "trouble replying to prog %d\n",
  993.                     pl->p_prognum);
  994.                 exit(1);
  995.             }
  996.             /* free the decoded arguments */
  997.             (void)svc_freeargs(transp, pl->p_inproc, xdrbuf);
  998.             return;
  999.         }
  1000.     (void) fprintf(stderr, "never registered prog %d\n", prog);
  1001.     exit(1);
  1002. }
  1003.  
  1004. Funky_Stuff
  1005. len=`wc -c < svc_simple.c`
  1006. if [ $len !=     4088 ] ; then
  1007.   echo error: svc_simple.c was $len bytes long, should have been     4088
  1008. fi
  1009. echo x - svc_tcp.c
  1010. cat > svc_tcp.c <<'Funky_Stuff'
  1011. /* @(#)svc_tcp.c    1.2 87/11/09 3.9 RPCSRC */
  1012. /*
  1013.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  1014.  * unrestricted use provided that this legend is included on all tape
  1015.  * media and as a part of the software program in whole or part.  Users
  1016.  * may copy or modify Sun RPC without charge, but are not authorized
  1017.  * to license or distribute it to anyone else except as part of a product or
  1018.  * program developed by the user.
  1019.  * 
  1020.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  1021.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  1022.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  1023.  * 
  1024.  * Sun RPC is provided with no support and without any obligation on the
  1025.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  1026.  * modification or enhancement.
  1027.  * 
  1028.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  1029.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  1030.  * OR ANY PART THEREOF.
  1031.  * 
  1032.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  1033.  * or profits or other special, indirect and consequential damages, even if
  1034.  * Sun has been advised of the possibility of such damages.
  1035.  * 
  1036.  * Sun Microsystems, Inc.
  1037.  * 2550 Garcia Avenue
  1038.  * Mountain View, California  94043
  1039.  */
  1040. #if !defined(lint) && defined(SCCSIDS)
  1041. static char sccsid[] = "@(#)svc_tcp.c 1.21 87/08/11 Copyr 1984 Sun Micro";
  1042. #endif
  1043.  
  1044. /*
  1045.  * svc_tcp.c, Server side for TCP/IP based RPC. 
  1046.  *
  1047.  * Copyright (C) 1984, Sun Microsystems, Inc.
  1048.  *
  1049.  * Actually implements two flavors of transporter -
  1050.  * a tcp rendezvouser (a listner and connection establisher)
  1051.  * and a record/tcp stream.
  1052.  */
  1053.  
  1054. #include <stdio.h>
  1055. #include <rpc/rpc.h>
  1056. #include <sys/socket.h>
  1057. #include <sys/time.h>
  1058. #include <errno.h>
  1059. extern bool_t abort();
  1060. extern errno;
  1061.  
  1062. /*
  1063.  * Ops vector for TCP/IP based rpc service handle
  1064.  */
  1065. static bool_t        svctcp_recv();
  1066. static enum xprt_stat    svctcp_stat();
  1067. static bool_t        svctcp_getargs();
  1068. static bool_t        svctcp_reply();
  1069. static bool_t        svctcp_freeargs();
  1070. static void        svctcp_destroy();
  1071.  
  1072. static struct xp_ops svctcp_op = {
  1073.     svctcp_recv,
  1074.     svctcp_stat,
  1075.     svctcp_getargs,
  1076.     svctcp_reply,
  1077.     svctcp_freeargs,
  1078.     svctcp_destroy
  1079. };
  1080.  
  1081. /*
  1082.  * Ops vector for TCP/IP rendezvous handler
  1083.  */
  1084. static bool_t        rendezvous_request();
  1085. static enum xprt_stat    rendezvous_stat();
  1086.  
  1087. static struct xp_ops svctcp_rendezvous_op = {
  1088.     rendezvous_request,
  1089.     rendezvous_stat,
  1090.     abort,
  1091.     abort,
  1092.     abort,
  1093.     svctcp_destroy
  1094. };
  1095.  
  1096. static int readtcp(), writetcp();
  1097. static SVCXPRT *makefd_xprt();
  1098.  
  1099. struct tcp_rendezvous { /* kept in xprt->xp_p1 */
  1100.     u_int sendsize;
  1101.     u_int recvsize;
  1102. };
  1103.  
  1104. struct tcp_conn {  /* kept in xprt->xp_p1 */
  1105.     enum xprt_stat strm_stat;
  1106.     u_long x_id;
  1107.     XDR xdrs;
  1108.     char verf_body[MAX_AUTH_BYTES];
  1109. };
  1110.  
  1111. /*
  1112.  * Usage:
  1113.  *    xprt = svctcp_create(sock, send_buf_size, recv_buf_size);
  1114.  *
  1115.  * Creates, registers, and returns a (rpc) tcp based transporter.
  1116.  * Once *xprt is initialized, it is registered as a transporter
  1117.  * see (svc.h, xprt_register).  This routine returns
  1118.  * a NULL if a problem occurred.
  1119.  *
  1120.  * If sock<0 then a socket is created, else sock is used.
  1121.  * If the socket, sock is not bound to a port then svctcp_create
  1122.  * binds it to an arbitrary port.  The routine then starts a tcp
  1123.  * listener on the socket's associated port.  In any (successful) case,
  1124.  * xprt->xp_sock is the registered socket number and xprt->xp_port is the
  1125.  * associated port number.
  1126.  *
  1127.  * Since tcp streams do buffered io similar to stdio, the caller can specify
  1128.  * how big the send and receive buffers are via the second and third parms;
  1129.  * 0 => use the system default.
  1130.  */
  1131. SVCXPRT *
  1132. svctcp_create(sock, sendsize, recvsize)
  1133.     register int sock;
  1134.     u_int sendsize;
  1135.     u_int recvsize;
  1136. {
  1137.     bool_t madesock = FALSE;
  1138.     register SVCXPRT *xprt;
  1139.     register struct tcp_rendezvous *r;
  1140.     struct sockaddr_in addr;
  1141.     int len = sizeof(struct sockaddr_in);
  1142.  
  1143.     if (sock == RPC_ANYSOCK) {
  1144.         if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
  1145.             perror("svctcp_.c - udp socket creation problem");
  1146.             return ((SVCXPRT *)NULL);
  1147.         }
  1148.         madesock = TRUE;
  1149.     }
  1150.     bzero((char *)&addr, sizeof (addr));
  1151.     addr.sin_family = AF_INET;
  1152.     if (bindresvport(sock, &addr)) {
  1153.         addr.sin_port = 0;
  1154.         (void)bind(sock, (struct sockaddr *)&addr, len);
  1155.     }
  1156.     if ((getsockname(sock, (struct sockaddr *)&addr, &len) != 0)  ||
  1157.         (listen(sock, 2) != 0)) {
  1158.         perror("svctcp_.c - cannot getsockname or listen");
  1159.         if (madesock)
  1160.                (void)close(sock);
  1161.         return ((SVCXPRT *)NULL);
  1162.     }
  1163.     r = (struct tcp_rendezvous *)mem_alloc(sizeof(*r));
  1164.     if (r == NULL) {
  1165.         (void) fprintf(stderr, "svctcp_create: out of memory\n");
  1166.         return (NULL);
  1167.     }
  1168.     r->sendsize = sendsize;
  1169.     r->recvsize = recvsize;
  1170.     xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
  1171.     if (xprt == NULL) {
  1172.         (void) fprintf(stderr, "svctcp_create: out of memory\n");
  1173.         return (NULL);
  1174.     }
  1175.     xprt->xp_p2 = NULL;
  1176.     xprt->xp_p1 = (caddr_t)r;
  1177.     xprt->xp_verf = _null_auth;
  1178.     xprt->xp_ops = &svctcp_rendezvous_op;
  1179.     xprt->xp_port = ntohs(addr.sin_port);
  1180.     xprt->xp_sock = sock;
  1181.     xprt_register(xprt);
  1182.     return (xprt);
  1183. }
  1184.  
  1185. /*
  1186.  * Like svtcp_create(), except the routine takes any *open* UNIX file
  1187.  * descriptor as its first input.
  1188.  */
  1189. SVCXPRT *
  1190. svcfd_create(fd, sendsize, recvsize)
  1191.     int fd;
  1192.     u_int sendsize;
  1193.     u_int recvsize;
  1194. {
  1195.  
  1196.     return (makefd_xprt(fd, sendsize, recvsize));
  1197. }
  1198.  
  1199. static SVCXPRT *
  1200. makefd_xprt(fd, sendsize, recvsize)
  1201.     int fd;
  1202.     u_int sendsize;
  1203.     u_int recvsize;
  1204. {
  1205.     register SVCXPRT *xprt;
  1206.     register struct tcp_conn *cd;
  1207.  
  1208.     xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
  1209.     if (xprt == (SVCXPRT *)NULL) {
  1210.         (void) fprintf(stderr, "svc_tcp: makefd_xprt: out of memory\n");
  1211.         goto done;
  1212.     }
  1213.     cd = (struct tcp_conn *)mem_alloc(sizeof(struct tcp_conn));
  1214.     if (cd == (struct tcp_conn *)NULL) {
  1215.         (void) fprintf(stderr, "svc_tcp: makefd_xprt: out of memory\n");
  1216.         mem_free((char *) xprt, sizeof(SVCXPRT));
  1217.         xprt = (SVCXPRT *)NULL;
  1218.         goto done;
  1219.     }
  1220.     cd->strm_stat = XPRT_IDLE;
  1221.     xdrrec_create(&(cd->xdrs), sendsize, recvsize,
  1222.         (caddr_t)xprt, readtcp, writetcp);
  1223.     xprt->xp_p2 = NULL;
  1224.     xprt->xp_p1 = (caddr_t)cd;
  1225.     xprt->xp_verf.oa_base = cd->verf_body;
  1226.     xprt->xp_addrlen = 0;
  1227.     xprt->xp_ops = &svctcp_op;  /* truely deals with calls */
  1228.     xprt->xp_port = 0;  /* this is a connection, not a rendezvouser */
  1229.     xprt->xp_sock = fd;
  1230.     xprt_register(xprt);
  1231.     done:
  1232.     return (xprt);
  1233. }
  1234.  
  1235. static bool_t
  1236. rendezvous_request(xprt)
  1237.     register SVCXPRT *xprt;
  1238. {
  1239.     int sock;
  1240.     struct tcp_rendezvous *r;
  1241.     struct sockaddr_in addr;
  1242.     int len;
  1243.  
  1244.     r = (struct tcp_rendezvous *)xprt->xp_p1;
  1245.     again:
  1246.     len = sizeof(struct sockaddr_in);
  1247.     if ((sock = accept(xprt->xp_sock, (struct sockaddr *)&addr,
  1248.         &len)) < 0) {
  1249.         if (errno == EINTR)
  1250.             goto again;
  1251.            return (FALSE);
  1252.     }
  1253.     /*
  1254.      * make a new transporter (re-uses xprt)
  1255.      */
  1256.     xprt = makefd_xprt(sock, r->sendsize, r->recvsize);
  1257.     xprt->xp_raddr = addr;
  1258.     xprt->xp_addrlen = len;
  1259.     return (FALSE); /* there is never an rpc msg to be processed */
  1260. }
  1261.  
  1262. static enum xprt_stat
  1263. rendezvous_stat()
  1264. {
  1265.  
  1266.     return (XPRT_IDLE);
  1267. }
  1268.  
  1269. static void
  1270. svctcp_destroy(xprt)
  1271.     register SVCXPRT *xprt;
  1272. {
  1273.     register struct tcp_conn *cd = (struct tcp_conn *)xprt->xp_p1;
  1274.  
  1275.     xprt_unregister(xprt);
  1276.     (void)close(xprt->xp_sock);
  1277.     if (xprt->xp_port != 0) {
  1278.         /* a rendezvouser socket */
  1279.         xprt->xp_port = 0;
  1280.     } else {
  1281.         /* an actual connection socket */
  1282.         XDR_DESTROY(&(cd->xdrs));
  1283.     }
  1284.     mem_free((caddr_t)cd, sizeof(struct tcp_conn));
  1285.     mem_free((caddr_t)xprt, sizeof(SVCXPRT));
  1286. }
  1287.  
  1288. /*
  1289.  * All read operations timeout after 35 seconds.
  1290.  * A timeout is fatal for the connection.
  1291.  */
  1292. static struct timeval wait_per_try = { 35, 0 };
  1293.  
  1294. /*
  1295.  * reads data from the tcp conection.
  1296.  * any error is fatal and the connection is closed.
  1297.  * (And a read of zero bytes is a half closed stream => error.)
  1298.  */
  1299. static int
  1300. readtcp(xprt, buf, len)
  1301.     register SVCXPRT *xprt;
  1302.     caddr_t buf;
  1303.     register int len;
  1304. {
  1305.     register int sock = xprt->xp_sock;
  1306. #ifdef FD_SETSIZE
  1307.     fd_set mask;
  1308.     fd_set readfds;
  1309.  
  1310.     FD_ZERO(&mask);
  1311.     FD_SET(sock, &mask);
  1312. #else
  1313.     register int mask = 1 << sock;
  1314.     int readfds;
  1315. #endif /* def FD_SETSIZE */
  1316.     do {
  1317.         readfds = mask;
  1318.         if (select(_rpc_dtablesize(), &readfds, (int*)NULL, (int*)NULL, 
  1319.                &wait_per_try) <= 0) {
  1320.             if (errno == EINTR) {
  1321.                 continue;
  1322.             }
  1323.             goto fatal_err;
  1324.         }
  1325. #ifdef FD_SETSIZE
  1326.     } while (!FD_ISSET(sock, &readfds));
  1327. #else
  1328.     } while (readfds != mask);
  1329. #endif /* def FD_SETSIZE */
  1330.     if ((len = read(sock, buf, len)) > 0) {
  1331.         return (len);
  1332.     }
  1333. fatal_err:
  1334.     ((struct tcp_conn *)(xprt->xp_p1))->strm_stat = XPRT_DIED;
  1335.     return (-1);
  1336. }
  1337.  
  1338. /*
  1339.  * writes data to the tcp connection.
  1340.  * Any error is fatal and the connection is closed.
  1341.  */
  1342. static int
  1343. writetcp(xprt, buf, len)
  1344.     register SVCXPRT *xprt;
  1345.     caddr_t buf;
  1346.     int len;
  1347. {
  1348.     register int i, cnt;
  1349.  
  1350.     for (cnt = len; cnt > 0; cnt -= i, buf += i) {
  1351.         if ((i = write(xprt->xp_sock, buf, cnt)) < 0) {
  1352.             ((struct tcp_conn *)(xprt->xp_p1))->strm_stat =
  1353.                 XPRT_DIED;
  1354.             return (-1);
  1355.         }
  1356.     }
  1357.     return (len);
  1358. }
  1359.  
  1360. static enum xprt_stat
  1361. svctcp_stat(xprt)
  1362.     SVCXPRT *xprt;
  1363. {
  1364.     register struct tcp_conn *cd =
  1365.         (struct tcp_conn *)(xprt->xp_p1);
  1366.  
  1367.     if (cd->strm_stat == XPRT_DIED)
  1368.         return (XPRT_DIED);
  1369.     if (! xdrrec_eof(&(cd->xdrs)))
  1370.         return (XPRT_MOREREQS);
  1371.     return (XPRT_IDLE);
  1372. }
  1373.  
  1374. static bool_t
  1375. svctcp_recv(xprt, msg)
  1376.     SVCXPRT *xprt;
  1377.     register struct rpc_msg *msg;
  1378. {
  1379.     register struct tcp_conn *cd =
  1380.         (struct tcp_conn *)(xprt->xp_p1);
  1381.     register XDR *xdrs = &(cd->xdrs);
  1382.  
  1383.     xdrs->x_op = XDR_DECODE;
  1384.     (void)xdrrec_skiprecord(xdrs);
  1385.     if (xdr_callmsg(xdrs, msg)) {
  1386.         cd->x_id = msg->rm_xid;
  1387.         return (TRUE);
  1388.     }
  1389.     return (FALSE);
  1390. }
  1391.  
  1392. static bool_t
  1393. svctcp_getargs(xprt, xdr_args, args_ptr)
  1394.     SVCXPRT *xprt;
  1395.     xdrproc_t xdr_args;
  1396.     caddr_t args_ptr;
  1397. {
  1398.  
  1399.     return ((*xdr_args)(&(((struct tcp_conn *)(xprt->xp_p1))->xdrs), args_ptr));
  1400. }
  1401.  
  1402. static bool_t
  1403. svctcp_freeargs(xprt, xdr_args, args_ptr)
  1404.     SVCXPRT *xprt;
  1405.     xdrproc_t xdr_args;
  1406.     caddr_t args_ptr;
  1407. {
  1408.     register XDR *xdrs =
  1409.         &(((struct tcp_conn *)(xprt->xp_p1))->xdrs);
  1410.  
  1411.     xdrs->x_op = XDR_FREE;
  1412.     return ((*xdr_args)(xdrs, args_ptr));
  1413. }
  1414.  
  1415. static bool_t
  1416. svctcp_reply(xprt, msg)
  1417.     SVCXPRT *xprt;
  1418.     register struct rpc_msg *msg;
  1419. {
  1420.     register struct tcp_conn *cd =
  1421.         (struct tcp_conn *)(xprt->xp_p1);
  1422.     register XDR *xdrs = &(cd->xdrs);
  1423.     register bool_t stat;
  1424.  
  1425.     xdrs->x_op = XDR_ENCODE;
  1426.     msg->rm_xid = cd->x_id;
  1427.     stat = xdr_replymsg(xdrs, msg);
  1428.     (void)xdrrec_endofrecord(xdrs, TRUE);
  1429.     return (stat);
  1430. }
  1431. Funky_Stuff
  1432. len=`wc -c < svc_tcp.c`
  1433. if [ $len !=    10278 ] ; then
  1434.   echo error: svc_tcp.c was $len bytes long, should have been    10278
  1435. fi
  1436. echo x - svc_udp.c
  1437. cat > svc_udp.c <<'Funky_Stuff'
  1438. /* @(#)svc_udp.c    1.1 87/11/04 3.9 RPCSRC */
  1439. /*
  1440.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  1441.  * unrestricted use provided that this legend is included on all tape
  1442.  * media and as a part of the software program in whole or part.  Users
  1443.  * may copy or modify Sun RPC without charge, but are not authorized
  1444.  * to license or distribute it to anyone else except as part of a product or
  1445.  * program developed by the user.
  1446.  * 
  1447.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  1448.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  1449.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  1450.  * 
  1451.  * Sun RPC is provided with no support and without any obligation on the
  1452.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  1453.  * modification or enhancement.
  1454.  * 
  1455.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  1456.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  1457.  * OR ANY PART THEREOF.
  1458.  * 
  1459.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  1460.  * or profits or other special, indirect and consequential damages, even if
  1461.  * Sun has been advised of the possibility of such damages.
  1462.  * 
  1463.  * Sun Microsystems, Inc.
  1464.  * 2550 Garcia Avenue
  1465.  * Mountain View, California  94043
  1466.  */
  1467. #if !defined(lint) && defined(SCCSIDS)
  1468. static char sccsid[] = "@(#)svc_udp.c 1.21 87/08/11 Copyr 1984 Sun Micro";
  1469. #endif
  1470.  
  1471. /*
  1472.  * svc_udp.c,
  1473.  * Server side for UDP/IP based RPC.  (Does some caching in the hopes of
  1474.  * achieving execute-at-most-once semantics.)
  1475.  *
  1476.  * Copyright (C) 1984, Sun Microsystems, Inc.
  1477.  */
  1478.  
  1479. #include <stdio.h>
  1480. #include <rpc/rpc.h>
  1481. #include <sys/socket.h>
  1482. #include <errno.h>
  1483.  
  1484.  
  1485. #define rpc_buffer(xprt) ((xprt)->xp_p1)
  1486. #define MAX(a, b)     ((a > b) ? a : b)
  1487.  
  1488. static bool_t        svcudp_recv();
  1489. static bool_t        svcudp_reply();
  1490. static enum xprt_stat    svcudp_stat();
  1491. static bool_t        svcudp_getargs();
  1492. static bool_t        svcudp_freeargs();
  1493. static void        svcudp_destroy();
  1494.  
  1495. static struct xp_ops svcudp_op = {
  1496.     svcudp_recv,
  1497.     svcudp_stat,
  1498.     svcudp_getargs,
  1499.     svcudp_reply,
  1500.     svcudp_freeargs,
  1501.     svcudp_destroy
  1502. };
  1503.  
  1504. extern int errno;
  1505.  
  1506. /*
  1507.  * kept in xprt->xp_p2
  1508.  */
  1509. struct svcudp_data {
  1510.     u_int   su_iosz;    /* byte size of send.recv buffer */
  1511.     u_long    su_xid;        /* transaction id */
  1512.     XDR    su_xdrs;    /* XDR handle */
  1513.     char    su_verfbody[MAX_AUTH_BYTES];    /* verifier body */
  1514.     char *     su_cache;    /* cached data, NULL if no cache */
  1515. };
  1516. #define    su_data(xprt)    ((struct svcudp_data *)(xprt->xp_p2))
  1517.  
  1518. /*
  1519.  * Usage:
  1520.  *    xprt = svcudp_create(sock);
  1521.  *
  1522.  * If sock<0 then a socket is created, else sock is used.
  1523.  * If the socket, sock is not bound to a port then svcudp_create
  1524.  * binds it to an arbitrary port.  In any (successful) case,
  1525.  * xprt->xp_sock is the registered socket number and xprt->xp_port is the
  1526.  * associated port number.
  1527.  * Once *xprt is initialized, it is registered as a transporter;
  1528.  * see (svc.h, xprt_register).
  1529.  * The routines returns NULL if a problem occurred.
  1530.  */
  1531. SVCXPRT *
  1532. svcudp_bufcreate(sock, sendsz, recvsz)
  1533.     register int sock;
  1534.     u_int sendsz, recvsz;
  1535. {
  1536.     bool_t madesock = FALSE;
  1537.     register SVCXPRT *xprt;
  1538.     register struct svcudp_data *su;
  1539.     struct sockaddr_in addr;
  1540.     int len = sizeof(struct sockaddr_in);
  1541.  
  1542.     if (sock == RPC_ANYSOCK) {
  1543.         if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
  1544.             perror("svcudp_create: socket creation problem");
  1545.             return ((SVCXPRT *)NULL);
  1546.         }
  1547.         madesock = TRUE;
  1548.     }
  1549.     bzero((char *)&addr, sizeof (addr));
  1550.     addr.sin_family = AF_INET;
  1551.     if (bindresvport(sock, &addr)) {
  1552.         addr.sin_port = 0;
  1553.         (void)bind(sock, (struct sockaddr *)&addr, len);
  1554.     }
  1555.     if (getsockname(sock, (struct sockaddr *)&addr, &len) != 0) {
  1556.         perror("svcudp_create - cannot getsockname");
  1557.         if (madesock)
  1558.             (void)close(sock);
  1559.         return ((SVCXPRT *)NULL);
  1560.     }
  1561.     xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
  1562.     if (xprt == NULL) {
  1563.         (void)fprintf(stderr, "svcudp_create: out of memory\n");
  1564.         return (NULL);
  1565.     }
  1566.     su = (struct svcudp_data *)mem_alloc(sizeof(*su));
  1567.     if (su == NULL) {
  1568.         (void)fprintf(stderr, "svcudp_create: out of memory\n");
  1569.         return (NULL);
  1570.     }
  1571.     su->su_iosz = ((MAX(sendsz, recvsz) + 3) / 4) * 4;
  1572.     if ((rpc_buffer(xprt) = mem_alloc(su->su_iosz)) == NULL) {
  1573.         (void)fprintf(stderr, "svcudp_create: out of memory\n");
  1574.         return (NULL);
  1575.     }
  1576.     xdrmem_create(
  1577.         &(su->su_xdrs), rpc_buffer(xprt), su->su_iosz, XDR_DECODE);
  1578.     su->su_cache = NULL;
  1579.     xprt->xp_p2 = (caddr_t)su;
  1580.     xprt->xp_verf.oa_base = su->su_verfbody;
  1581.     xprt->xp_ops = &svcudp_op;
  1582.     xprt->xp_port = ntohs(addr.sin_port);
  1583.     xprt->xp_sock = sock;
  1584.     xprt_register(xprt);
  1585.     return (xprt);
  1586. }
  1587.  
  1588. SVCXPRT *
  1589. svcudp_create(sock)
  1590.     int sock;
  1591. {
  1592.  
  1593.     return(svcudp_bufcreate(sock, UDPMSGSIZE, UDPMSGSIZE));
  1594. }
  1595.  
  1596. static enum xprt_stat
  1597. svcudp_stat(xprt)
  1598.     SVCXPRT *xprt;
  1599. {
  1600.  
  1601.     return (XPRT_IDLE); 
  1602. }
  1603.  
  1604. static bool_t
  1605. svcudp_recv(xprt, msg)
  1606.     register SVCXPRT *xprt;
  1607.     struct rpc_msg *msg;
  1608. {
  1609.     register struct svcudp_data *su = su_data(xprt);
  1610.     register XDR *xdrs = &(su->su_xdrs);
  1611.     register int rlen;
  1612.     char *reply;
  1613.     u_long replylen;
  1614.  
  1615.     again:
  1616.     xprt->xp_addrlen = sizeof(struct sockaddr_in);
  1617.     rlen = recvfrom(xprt->xp_sock, rpc_buffer(xprt), (int) su->su_iosz,
  1618.         0, (struct sockaddr *)&(xprt->xp_raddr), &(xprt->xp_addrlen));
  1619.     if (rlen == -1 && errno == EINTR)
  1620.         goto again;
  1621.     if (rlen < 4*sizeof(u_long))
  1622.         return (FALSE);
  1623.     xdrs->x_op = XDR_DECODE;
  1624.     XDR_SETPOS(xdrs, 0);
  1625.     if (! xdr_callmsg(xdrs, msg))
  1626.         return (FALSE);
  1627.     su->su_xid = msg->rm_xid;
  1628.     if (su->su_cache != NULL) {
  1629.         if (cache_get(xprt, msg, &reply, &replylen)) {
  1630.             (void) sendto(xprt->xp_sock, reply, (int) replylen, 0,
  1631.               (struct sockaddr *) &xprt->xp_raddr, (int) &xprt->xp_addrlen);    
  1632.             return(FALSE);
  1633.         }
  1634.     }
  1635.     return (TRUE);
  1636. }
  1637.  
  1638. static bool_t
  1639. svcudp_reply(xprt, msg)
  1640.     register SVCXPRT *xprt; 
  1641.     struct rpc_msg *msg; 
  1642. {
  1643.     register struct svcudp_data *su = su_data(xprt);
  1644.     register XDR *xdrs = &(su->su_xdrs);
  1645.     register int slen;
  1646.     register bool_t stat = FALSE;
  1647.  
  1648.     xdrs->x_op = XDR_ENCODE;
  1649.     XDR_SETPOS(xdrs, 0);
  1650.     msg->rm_xid = su->su_xid;
  1651.     if (xdr_replymsg(xdrs, msg)) {
  1652.         slen = (int)XDR_GETPOS(xdrs);
  1653.         if (sendto(xprt->xp_sock, rpc_buffer(xprt), slen, 0,
  1654.             (struct sockaddr *)&(xprt->xp_raddr), xprt->xp_addrlen)
  1655.             == slen) {
  1656.             stat = TRUE;
  1657.             if (su->su_cache && slen >= 0) {
  1658.                 cache_set(xprt, (u_long) slen);
  1659.             }
  1660.         }
  1661.     }
  1662.     return (stat);
  1663. }
  1664.  
  1665. static bool_t
  1666. svcudp_getargs(xprt, xdr_args, args_ptr)
  1667.     SVCXPRT *xprt;
  1668.     xdrproc_t xdr_args;
  1669.     caddr_t args_ptr;
  1670. {
  1671.  
  1672.     return ((*xdr_args)(&(su_data(xprt)->su_xdrs), args_ptr));
  1673. }
  1674.  
  1675. static bool_t
  1676. svcudp_freeargs(xprt, xdr_args, args_ptr)
  1677.     SVCXPRT *xprt;
  1678.     xdrproc_t xdr_args;
  1679.     caddr_t args_ptr;
  1680. {
  1681.     register XDR *xdrs = &(su_data(xprt)->su_xdrs);
  1682.  
  1683.     xdrs->x_op = XDR_FREE;
  1684.     return ((*xdr_args)(xdrs, args_ptr));
  1685. }
  1686.  
  1687. static void
  1688. svcudp_destroy(xprt)
  1689.     register SVCXPRT *xprt;
  1690. {
  1691.     register struct svcudp_data *su = su_data(xprt);
  1692.  
  1693.     xprt_unregister(xprt);
  1694.     (void)close(xprt->xp_sock);
  1695.     XDR_DESTROY(&(su->su_xdrs));
  1696.     mem_free(rpc_buffer(xprt), su->su_iosz);
  1697.     mem_free((caddr_t)su, sizeof(struct svcudp_data));
  1698.     mem_free((caddr_t)xprt, sizeof(SVCXPRT));
  1699. }
  1700.  
  1701.  
  1702. /***********this could be a separate file*********************/
  1703.  
  1704. /*
  1705.  * Fifo cache for udp server
  1706.  * Copies pointers to reply buffers into fifo cache
  1707.  * Buffers are sent again if retransmissions are detected.
  1708.  */
  1709.  
  1710. #define SPARSENESS 4    /* 75% sparse */
  1711.  
  1712. #define CACHE_PERROR(msg)    \
  1713.     (void) fprintf(stderr,"%s\n", msg)
  1714.  
  1715. #define ALLOC(type, size)    \
  1716.     (type *) mem_alloc((unsigned) (sizeof(type) * (size)))
  1717.  
  1718. #define BZERO(addr, type, size)     \
  1719.     bzero((char *) addr, sizeof(type) * (int) (size)) 
  1720.  
  1721. /*
  1722.  * An entry in the cache
  1723.  */
  1724. typedef struct cache_node *cache_ptr;
  1725. struct cache_node {
  1726.     /*
  1727.      * Index into cache is xid, proc, vers, prog and address
  1728.      */
  1729.     u_long cache_xid;
  1730.     u_long cache_proc;
  1731.     u_long cache_vers;
  1732.     u_long cache_prog;
  1733.     struct sockaddr_in cache_addr;
  1734.     /*
  1735.      * The cached reply and length
  1736.      */
  1737.     char * cache_reply;
  1738.     u_long cache_replylen;
  1739.     /*
  1740.       * Next node on the list, if there is a collision
  1741.      */
  1742.     cache_ptr cache_next;    
  1743. };
  1744.  
  1745.  
  1746.  
  1747. /*
  1748.  * The entire cache
  1749.  */
  1750. struct udp_cache {
  1751.     u_long uc_size;        /* size of cache */
  1752.     cache_ptr *uc_entries;    /* hash table of entries in cache */
  1753.     cache_ptr *uc_fifo;    /* fifo list of entries in cache */
  1754.     u_long uc_nextvictim;    /* points to next victim in fifo list */
  1755.     u_long uc_prog;        /* saved program number */
  1756.     u_long uc_vers;        /* saved version number */
  1757.     u_long uc_proc;        /* saved procedure number */
  1758.     struct sockaddr_in uc_addr; /* saved caller's address */
  1759. };
  1760.  
  1761.  
  1762. /*
  1763.  * the hashing function
  1764.  */
  1765. #define CACHE_LOC(transp, xid)    \
  1766.  (xid % (SPARSENESS*((struct udp_cache *) su_data(transp)->su_cache)->uc_size))    
  1767.  
  1768.  
  1769. /*
  1770.  * Enable use of the cache. 
  1771.  * Note: there is no disable.
  1772.  */
  1773. svcudp_enablecache(transp, size)
  1774.     SVCXPRT *transp;
  1775.     u_long size;
  1776. {
  1777.     struct svcudp_data *su = su_data(transp);
  1778.     struct udp_cache *uc;
  1779.  
  1780.     if (su->su_cache != NULL) {
  1781.         CACHE_PERROR("enablecache: cache already enabled");
  1782.         return(0);    
  1783.     }
  1784.     uc = ALLOC(struct udp_cache, 1);
  1785.     if (uc == NULL) {
  1786.         CACHE_PERROR("enablecache: could not allocate cache");
  1787.         return(0);
  1788.     }
  1789.     uc->uc_size = size;
  1790.     uc->uc_nextvictim = 0;
  1791.     uc->uc_entries = ALLOC(cache_ptr, size * SPARSENESS);
  1792.     if (uc->uc_entries == NULL) {
  1793.         CACHE_PERROR("enablecache: could not allocate cache data");
  1794.         return(0);
  1795.     }
  1796.     BZERO(uc->uc_entries, cache_ptr, size * SPARSENESS);
  1797.     uc->uc_fifo = ALLOC(cache_ptr, size);
  1798.     if (uc->uc_fifo == NULL) {
  1799.         CACHE_PERROR("enablecache: could not allocate cache fifo");
  1800.         return(0);
  1801.     }
  1802.     BZERO(uc->uc_fifo, cache_ptr, size);
  1803.     su->su_cache = (char *) uc;
  1804.     return(1);
  1805. }
  1806.  
  1807.  
  1808. /*
  1809.  * Set an entry in the cache
  1810.  */
  1811. static
  1812. cache_set(xprt, replylen)
  1813.     SVCXPRT *xprt;
  1814.     u_long replylen;    
  1815. {
  1816.     register cache_ptr victim;    
  1817.     register cache_ptr *vicp;
  1818.     register struct svcudp_data *su = su_data(xprt);
  1819.     struct udp_cache *uc = (struct udp_cache *) su->su_cache;
  1820.     u_int loc;
  1821.     char *newbuf;
  1822.  
  1823.     /*
  1824.       * Find space for the new entry, either by
  1825.      * reusing an old entry, or by mallocing a new one
  1826.      */
  1827.     victim = uc->uc_fifo[uc->uc_nextvictim];
  1828.     if (victim != NULL) {
  1829.         loc = CACHE_LOC(xprt, victim->cache_xid);
  1830.         for (vicp = &uc->uc_entries[loc]; 
  1831.           *vicp != NULL && *vicp != victim; 
  1832.           vicp = &(*vicp)->cache_next) 
  1833.                 ;
  1834.         if (*vicp == NULL) {
  1835.             CACHE_PERROR("cache_set: victim not found");
  1836.             return;
  1837.         }
  1838.         *vicp = victim->cache_next;    /* remote from cache */
  1839.         newbuf = victim->cache_reply;
  1840.     } else {
  1841.         victim = ALLOC(struct cache_node, 1);
  1842.         if (victim == NULL) {
  1843.             CACHE_PERROR("cache_set: victim alloc failed");
  1844.             return;
  1845.         }
  1846.         newbuf = mem_alloc(su->su_iosz);
  1847.         if (newbuf == NULL) {
  1848.             CACHE_PERROR("cache_set: could not allocate new rpc_buffer");
  1849.             return;
  1850.         }
  1851.     }
  1852.  
  1853.     /*
  1854.      * Store it away
  1855.      */
  1856.     victim->cache_replylen = replylen;
  1857.     victim->cache_reply = rpc_buffer(xprt);
  1858.     rpc_buffer(xprt) = newbuf;
  1859.     xdrmem_create(&(su->su_xdrs), rpc_buffer(xprt), su->su_iosz, XDR_ENCODE);
  1860.     victim->cache_xid = su->su_xid;
  1861.     victim->cache_proc = uc->uc_proc;
  1862.     victim->cache_vers = uc->uc_vers;
  1863.     victim->cache_prog = uc->uc_prog;
  1864.     victim->cache_addr = uc->uc_addr;
  1865.     loc = CACHE_LOC(xprt, victim->cache_xid);
  1866.     victim->cache_next = uc->uc_entries[loc];    
  1867.     uc->uc_entries[loc] = victim;
  1868.     uc->uc_fifo[uc->uc_nextvictim++] = victim;
  1869.     uc->uc_nextvictim %= uc->uc_size;
  1870. }
  1871.  
  1872. /*
  1873.  * Try to get an entry from the cache
  1874.  * return 1 if found, 0 if not found
  1875.  */
  1876. static
  1877. cache_get(xprt, msg, replyp, replylenp)
  1878.     SVCXPRT *xprt;
  1879.     struct rpc_msg *msg;
  1880.     char **replyp;
  1881.     u_long *replylenp;
  1882. {
  1883.     u_int loc;
  1884.     register cache_ptr ent;
  1885.     register struct svcudp_data *su = su_data(xprt);
  1886.     register struct udp_cache *uc = (struct udp_cache *) su->su_cache;
  1887.  
  1888. #    define EQADDR(a1, a2)    (bcmp((char*)&a1, (char*)&a2, sizeof(a1)) == 0)
  1889.  
  1890.     loc = CACHE_LOC(xprt, su->su_xid);
  1891.     for (ent = uc->uc_entries[loc]; ent != NULL; ent = ent->cache_next) {
  1892.         if (ent->cache_xid == su->su_xid &&
  1893.           ent->cache_proc == uc->uc_proc &&
  1894.           ent->cache_vers == uc->uc_vers &&
  1895.           ent->cache_prog == uc->uc_prog &&
  1896.           EQADDR(ent->cache_addr, uc->uc_addr)) {
  1897.             *replyp = ent->cache_reply;
  1898.             *replylenp = ent->cache_replylen;
  1899.             return(1);
  1900.         }
  1901.     }
  1902.     /*
  1903.      * Failed to find entry
  1904.      * Remember a few things so we can do a set later
  1905.      */
  1906.     uc->uc_proc = msg->rm_call.cb_proc;
  1907.     uc->uc_vers = msg->rm_call.cb_vers;
  1908.     uc->uc_prog = msg->rm_call.cb_prog;
  1909.     uc->uc_addr = xprt->xp_raddr;
  1910.     return(0);
  1911. }
  1912.  
  1913. Funky_Stuff
  1914. len=`wc -c < svc_udp.c`
  1915. if [ $len !=    12207 ] ; then
  1916.   echo error: svc_udp.c was $len bytes long, should have been    12207
  1917. fi
  1918. echo x - types.h
  1919. cat > types.h <<'Funky_Stuff'
  1920. /* @(#)types.h    1.2 87/11/07 3.9 RPCSRC */
  1921. /*
  1922.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  1923.  * unrestricted use provided that this legend is included on all tape
  1924.  * media and as a part of the software program in whole or part.  Users
  1925.  * may copy or modify Sun RPC without charge, but are not authorized
  1926.  * to license or distribute it to anyone else except as part of a product or
  1927.  * program developed by the user.
  1928.  * 
  1929.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  1930.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  1931.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  1932.  * 
  1933.  * Sun RPC is provided with no support and without any obligation on the
  1934.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  1935.  * modification or enhancement.
  1936.  * 
  1937.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  1938.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  1939.  * OR ANY PART THEREOF.
  1940.  * 
  1941.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  1942.  * or profits or other special, indirect and consequential damages, even if
  1943.  * Sun has been advised of the possibility of such damages.
  1944.  * 
  1945.  * Sun Microsystems, Inc.
  1946.  * 2550 Garcia Avenue
  1947.  * Mountain View, California  94043
  1948.  */
  1949. /*      @(#)types.h 1.18 87/07/24 SMI      */
  1950.  
  1951. /*
  1952.  * Rpc additions to <sys/types.h>
  1953.  */
  1954. #ifndef __TYPES_RPC_HEADER__
  1955. #define __TYPES_RPC_HEADER__
  1956.  
  1957. #define    bool_t    int
  1958. #define    enum_t    int
  1959. #define    FALSE    (0)
  1960. #define    TRUE    (1)
  1961. #define __dontcare__    -1
  1962. #ifndef NULL
  1963. #    define NULL 0
  1964. #endif
  1965.  
  1966. extern char *malloc();
  1967. #define mem_alloc(bsize)    malloc(bsize)
  1968. #define mem_free(ptr, bsize)    free(ptr)
  1969.  
  1970. #ifndef makedev /* ie, we haven't already included it */
  1971. #include <sys/types.h>
  1972. #endif
  1973. /*#include <sys/time.h>*/
  1974.  
  1975. #endif /* ndef __TYPES_RPC_HEADER__ */
  1976. Funky_Stuff
  1977. len=`wc -c < types.h`
  1978. if [ $len !=     1847 ] ; then
  1979.   echo error: types.h was $len bytes long, should have been     1847
  1980. fi
  1981. cd ..
  1982. echo more files to follow
  1983. exit
  1984.